Objectif :
Reussir à affecter un IRIS à partir d’une adresse.

1 Description des données

1.1 Adresses initiales :

adresses <- read.csv2("R:/Masters/Stage_G_BARETH/Geocodage/IRIS/IRIS_EDI/Adresse.csv")
head(adresses)

Le tableau de données Adresse.csv est composé de 5 colonnes :
VOIE fait référence à la voie de l’adresse désirée \(\pm\) le numéro.
CPOST_TUMEUR \(\rightarrow\) code postal.
CINSEE_TUMEUR \(\rightarrow\) code Insee.
latitude \(\rightarrow\) coordonnées géographiques latitudinale.
longitude \(\rightarrow\) coordonnées géographiques longitudinale.

1.2 IRIS :

IRIS : Un sigle qui signifiait « Ilots Regroupés pour l’Information Statistique » et qui faisait référence à la taille visée de 2 000 habitants par maille élémentaire. Depuis, l’IRIS (appellation qui se substitue désormais à IRIS2000) constitue la brique de base en matière de diffusion de données infra-communales.
Un IRIS est une unité géographique définie par l’INSEE pour les besoins des recensements sur l’ensemble des communes de plus de 10 000 habitants et la plupart des communes de 5 000 à 10 000 habitants.

Pour savoir à quel IRIS correspondent nos adresses, nous avons besoin de leur limites géographiques.
Cela est donné par l’INSEE à cette adresse : https://geoservices.ign.fr/contoursiris

Ce fichier contient des données géographiques permettant de créer des polygonnes. Pour pouvoir lire ces coordonnées et les transformer au format sfc, il est nécessaire d’utiliser la fonction st_read et la librairie sf.

library(sf)
## Linking to GEOS 3.9.1, GDAL 3.2.1, PROJ 7.2.1; sf_use_s2() is TRUE
Contours_IRIS <- st_read("R://Masters//Stage_G_BARETH//Geocodage//IRIS//IRIS_EDI//CONTOURS-IRIS_2-1__SHP__FRA_2021-01-01//CONTOURS-IRIS//1_DONNEES_LIVRAISON_2021-06-00217//CONTOURS-IRIS_2-1_SHP_LAMB93_FXX-2021")
## Reading layer `CONTOURS-IRIS' from data source 
##   `R:\Masters\Stage_G_BARETH\Geocodage\IRIS\IRIS_EDI\CONTOURS-IRIS_2-1__SHP__FRA_2021-01-01\CONTOURS-IRIS\1_DONNEES_LIVRAISON_2021-06-00217\CONTOURS-IRIS_2-1_SHP_LAMB93_FXX-2021' 
##   using driver `ESRI Shapefile'
## Simple feature collection with 48589 features and 6 fields
## Geometry type: MULTIPOLYGON
## Dimension:     XY
## Bounding box:  xmin: 99040 ymin: 6049662 xmax: 1242445 ymax: 7110479
## Projected CRS: RGF93 / Lambert-93

Voici un petit aperçu de la table de données Contours_IRIS :

head(Contours_IRIS)

INSEE_COM \(\rightarrow\) Code Insee.
NOM_COM \(\rightarrow\) Nom de la commune.
IRIS \(\rightarrow\) Numéro de l’IRIS
CODE_IRIS \(\rightarrow\) Code complet de l’IRIS comprenant le Code Insee et le numéro de l’IRIS.
NOM_IRIS \(\rightarrow\) Nom de l’IRIS
TYP_IRIS \(\rightarrow\) Type de l’IRIS. Il en existe 3 types : A (Activité); H (Habitat); D (divers) et Z (La commune n’est pas divisée en IRIS)
geometry \(\rightarrow\) Données géométriques permettant la cartographie.

1.3 API :

Une API (interface de programmation d’application) est un ensemble de protocoles permettant à deux services de discuter ensemble.

Les API sont parfois considérées comme des contrats, avec une documentation qui constitue un accord entre les parties : si la partie 1 envoie une requête à distance selon une structure particulière, le logiciel de la partie 2 devra répondre selon les conditions définies.

Dans cet exemple, nous cherchons à savoir quelles sont les coordonnées latitudinales et longitudinales. Pour se faire, nous allons faire communiquer notre logiciel avec la plateforme de la BAN (base d’adresse nationale) selon un protocole (l’API) afin qu’elle nous renvoie les informations dont nous avons besoin.

1.4 cURL et protocoles :

cURL (abréviation de client URL request library : « bibliothèque de requêtes aux URL pour les clients ») est une interface en ligne de commande, destinée à récupérer le contenu d’une ressource accessible par un réseau informatique.

cURL c’est une librairie permettant de communiquer avec de nombreux types de serveurs en utilisant les protocoles standards (HTTP,HTTPS,FTP,Telnet,LDAP,etc.).


cURL supporte les méthodes de requêtes en HEAD,GET et POST ainsi qu’en PUT (etc…) :
HEAD: sers à récupérer l’en-tête d’une page internet sans le corps de la page. Ce genre de requête offre l’avantage d’être très légère lors de son exécution aussi bien en ressource qu’en bande passante, elle est parfaite pour contrôler si un site internet répond.
GET : la méthode GET demande au serveur distant la page (ou le fichier), dans les standards ce type de méthode sert uniquement à récupérer des données.
POST : la méthode POST sert à envoyer au serveur distant les données (ressources) indiquées.
PUT : crée une nouvelle ressource ou remplace une représentation de la ressource ciblée par le contenu de la requête.
DELETE : la méthode DELETE supprime la ressource indiquée.

1.5 Réponses HTTP et HTTPS :

Explications rapides sur HTTP et HTTPS pour comprendre l’outil CURL :
Cette librairie gère les protocoles HTTP et HTTPS et bien que les deux protocoles de communication visent le même objectif, la couche de sécurité n’est clairement pas la même.
Le protocole HTTP transfert des données de manières non sécurisé, alors que le HTTPS permet de transmettre des données dans un canal de communication crypté entre les deux points, en SSL (Secure Socket Layer).

Une réponse HTTP est un ensemble de lignes envoyées au navigateur par le serveur.
Elle comprend:
Une ligne de statut. C’est une ligne précisant la version du protocole utilisé et l’état du traitement de la requête à l’aide d’un code et d’un texte explicatif. La ligne comprend trois éléments devant être séparés par un espace : La version du protocole utilisé; Le code de statut;La signification du code.

Les champs d’en-tête de la réponse: il s’agit d’un ensemble de lignes facultatives permettant de donner des informations supplémentaires sur la réponse et/ou le serveur. Chacune de ces lignes est composée d’un nom qualifiant le type d’en-tête, suivi de deux points (:) et de la valeur de l’en-tête

Le corps de la réponse: il contient le document demandé

Réponse d’une requête HTTP https://developer.mozilla.org/fr/docs/Web/HTTP/Overview

1.6 Proxy :

“Un proxy (litt. « mandataire ») est un composant logiciel informatique qui joue le rôle d’intermédiaire en se plaçant entre deux hôtes pour faciliter ou surveiller leurs échanges.

Dans le cadre plus précis des réseaux informatiques, un proxy est alors un programme servant d’intermédiaire pour accéder à un autre réseau, généralement Internet. Par extension, on appelle aussi « proxy » un matériel comme un serveur mis en place pour assurer le fonctionnement de tels services.” (https://fr.wikipedia.org/wiki/Proxy#/media/Fichier:Proxy_concept_fr.svg)
Proxy
Comment passer outre ?
Sur windows : aller dans paramètres > proxy > Configuration manuelle du Proxy. Recréer les lignes de commandes ci dessous avec l’adresse (ex : https://cache.univ-poitiers.fr) et le port (ex:3128) qui vous correspondent.

Sys.setenv(http_proxy = "https://cache.univ-poitiers.fr:3128", https_proxy="http://cache.univ-poitiers.fr:3128")

2 Recherche Longitude/latitude.

2.1 Description :

Le site national des adresses (https://adresse.data.gouv.fr/) va nous permettre à partir des informations dont nous disposons de trouver l’adresse la plus exacte possible ainsi que plusieurs attributs spécifiques et notament les coordonnées longitude/latitude.

Base Adresse Nationale

2.2 API :

2.2.1 protocole :

Comme décris plus tôt, une API est un ensemble de protocoles. Ici, pour que notre requête HTTPS soit conforme à ce que le logiciel attende, il nous faut respecter la formulation ci-dessous : requête pour API Les coordonnées GeoJSON sont exprimées en WGS-84 (EPSG 4326)

2.2.2 Requête :

Création d’une fonction qui se nomme callAPI et prenant en 3 paramètres (voie, Cpost, CInsee) et retournant une liste constituée de la longitude et de la latitude.
Cette fonction commence par créer une variable voie_sansEspace prenant le paramètre voie et va remplacer tous les espaces compris dans cette “voie” par des “+”.
Ensuite elle créee une première URL commençant par https://api-adresse.data.gouv.fr/search/?q à laquelle on rajoute, en séparant par un “=”, la variable voie_sansEspace que l’on vient de créer.
S’en suit une série de transformations de même type afin de créer URL finale URLfinale que nous pourrons envoyer dans notre requête. 

callAPI <- function (voie, Cpost, CInsee){
  voie_sansEspace<- gsub (" ", "+", voie)
  MyURL <- paste ("https://api-adresse.data.gouv.fr/search/?q", voie_sansEspace, sep="=")
  
  #Objectif numero 2 : https://api-adresse.data.gouv.fr/search/?q=70+avenue+Le+Jumel&postcode=14600 
  postcode <- paste ("postcode", Cpost, sep = "=")
  URL11 <- paste(MyURL,postcode, sep = "&")
  
  #objectif numéro 3 : https://api-adresse.data.gouv.fr/search/?q=paris&citycode=75056
  citycode <- paste("citycode", CInsee, sep = "=")
  URL12 <- paste(URL11, citycode, sep = "&")
  
  #objectif numéro 4 : https://api-adresse.data.gouv.fr/search/?q=70+avenue+Le+Jumel&postcode=14600&limit=1
  #avec une limite de 1 pour avoir le résultat le plus pertinent. 
  URLfinale <- paste(URL12, "limit=1", sep = "&")
  
  #On fait une requête de type GET à la BAN afin qu'elle nous retourne les données voulues. 
  Coordonnees <- GET(URLfinale)
 
  #Le corps de la réponse va être éclaté de façon à pouvoir la lire comme un tableau de données. 
  body <- content(Coordonnees, as="parsed")
  
  longitude_a_noter <- body$features[[1]]$geometry$coordinates[[1]]
  latitude_a_noter <- body$features[[1]]$geometry$coordinates[[2]]
  print(longitude_a_noter)
  print(latitude_a_noter)
  
  return(c(longitude_a_noter,latitude_a_noter ))
  
}

2.2.3 Réponse :

réponse envoyée par la BAN
Il faut voir la réponse comme un grand tableau qui aurait été trouné de 90° dans le sens inverse des aiguilles d’une montre (et en miroir).
On aurait une première colonne type, une seconde version et la troisième colonne features qui comprend les données qui nous interressent.
Cette colonne features est elle-même composée de plusieurs colonnes qui elles-mêmes en regroupent d’autre et ainsi de suite.

#Le corps de la réponse va être éclaté de façon à pouvoir la lire comme un tableau de données. 
  body <- content(Coordonnees, as="parsed")
  
# [[1]] revient à écrire $1 
  longitude_a_noter <- body$features[[1]]$geometry$coordinates[[1]]
  latitude_a_noter <- body$features[[1]]$geometry$coordinates[[2]]
  print(longitude_a_noter)
  print(latitude_a_noter)
  
  return(c(longitude_a_noter,latitude_a_noter ))

2.2.4 Intégration :

Explication du code :
Pour chaque ligne dans mon tableau de donnée adresses, crée les variables voie, Cpost, CInsee en allant chercher les informations nécessaires en enlevant les ponctuations (,;?!).
Puis crée 2 nouvelles colonnes (longitude et latitude), toujours dans le tableau adresses en leur donnant la première et deuxième valeur contenue dans la variable Adresse_totale.

for(row in 1:nrow(adresses)) {
  voie <- gsub("[[:punct:]]", "", adresses[row, "VOIE"])
  Cpost <- gsub("[[:punct:]]", "", adresses [row, "CPOST_TUMEUR"])
  CInsee <- gsub("[[:punct:]]", "", adresses [row, "CINSEE_TUMEUR"])
  
  Adresse_totale <- callAPI (voie,Cpost, CInsee)
  #la liste que nous renvoie l'API est intégrée dans la variable Adresse_totale.
  
  head(adresses)
  adresses[row, "longitude"] <- Adresse_totale[1]
  adresses[row, "latitude"] <- Adresse_totale[2]
  
  }

2.3 Code intégral :

library(httr)
callAPI <- function (voie, Cpost, CInsee){
  voie_sansEspace<- gsub (" ", "+", voie)
  MyURL <- paste ("https://api-adresse.data.gouv.fr/search/?q", voie_sansEspace, sep="=")

  #Objectif numero 2 : https://api-adresse.data.gouv.fr/search/?q=70+avenue+Le+Jumel&postcode=14600 
  postcode <- paste ("postcode", Cpost, sep = "=")
  URL11 <- paste(MyURL,postcode, sep = "&")
  
  #objectif numéro 3 : https://api-adresse.data.gouv.fr/search/?q=paris&citycode=75056
  citycode <- paste("citycode", CInsee, sep = "=")
  URL12 <- paste(URL11, citycode, sep = "&")
  
  #objectif numéro 4 : https://api-adresse.data.gouv.fr/search/?q=70+avenue+Le+Jumel&postcode=14600&limit=1
  #avec une limite de 1 pour avoir le résultat le plus pertinent. 
  URLfinale <- paste(URL12, "limit=1", sep = "&")
  
  Coordonnees <- GET(URLfinale)
  body <- content(Coordonnees, as="parsed")
  
  longitude_a_noter <- body$features[[1]]$geometry$coordinates[[1]]
  latitude_a_noter <- body$features[[1]]$geometry$coordinates[[2]]
  print(longitude_a_noter)
  print(latitude_a_noter)
  
  return(c(longitude_a_noter,latitude_a_noter ))
  
}

### Début de lecture du code

for(row in 1:nrow(adresses)) {
  voie <- gsub("[[:punct:]]", " ", adresses[row, "VOIE"])
  Cpost <- gsub("[[:punct:]]", " ", adresses [row, "CPOST_TUMEUR"])
  CInsee <- gsub("[[:punct:]]", " ", adresses [row, "CINSEE_TUMEUR"])
  
  Adresse_totale <- callAPI (voie,Cpost, CInsee)
  #Pour voir ce que fait la fonction callAPI voir la déclaration de cette variable plus haut dans le code.
  
  adresses[row, "longitude"] <- Adresse_totale[1]
  adresses[row, "latitude"] <- Adresse_totale[2]
  
}

3 Retrouver l’IRIS :

3.1 API :

3.1.1 Requête

Il nous faut pour cela, utiliser le projet pyris (https://gitlab.com/Oslandia/pyris) et utiliser à nouveau une API (voir ci dessus pour plus d’explications).

Cliquer sur ce lien pour voir quels sont les protocoles à respecter pour la requête HTTPS : https://pyris.datajazz.io/doc/ protocoles

3.1.2 Réponse (body) :

body de la requête

3.1.3 Code :

villes <- c()
codeIris <- c()

for (i in 1:nrow(adresses)) {
 
  # Création de l'URL afin d'envoyer notre requête https. 
  # Pour longitude/ latitude : 
  # https://pyris.datajazz.io/api/coords?geojson=false&lat=45.645606&lon=-1.083828
  
  URL1 <- c("https://pyris.datajazz.io/api/coords?geojson=false&")

 latitude <- adresses[i, "latitude"]
  Lat <- paste("lat", latitude, sep = "=")
  
  URL2 <- paste(URL1, Lat, sep = "&")
  
  longitude <- adresses[i, "longitude"]
  Lon <- paste("lon", longitude, sep = "=")
  
  URL3 <- paste(URL2, Lon, sep = "&")
  
  r <- GET(URL3)
  
  #####Response body : long/lat
  # {
  #   "citycode": "17380",
  #   "name": "Saint-Palais-sur-Mer",
  #   "type": "Z",
  #   "complete_code": "173800000",
  #   "city": "Saint-Palais-sur-Mer",
  #   "iris": "0000"
  # }
  
  body <- content(r, as="parsed")
  
  complete_code <- body$complete_code
  city <- body$city
  iris <- body$iris
  type_iris <- body$type
  
  print(paste(c(complete_code, city, type_iris, iris)))
  
  villes <- append(villes, city)
  codeIris <- append(codeIris, complete_code)
  adresses[i,"CODE_IRIS"] <- complete_code
  
  }

head(adresses)
adresses

3.1.4 Population :

Pour aller plus loin dans l’affichage de carte choroplèthe (représentation des données par des plages de valeur discrétisées), il est possible toujours avec la même API de trouver la population résidant dans les IRIS.

for (i in 1:nrow(adresses)) {
# Si on veut avoir des données sur le nombre de femmes ou hommes en fonction de l'IRIS.
# https://pyris.datajazz.io/api/insee/population/010010000

  URL7 <- c("https://pyris.datajazz.io/api/insee/population/")
  CODE <- adresses[i,"CODE_IRIS"]
  URL8 <- paste(URL7, CODE, sep = "")
  print(URL8)

  donnees_sex <- GET(URL8)

   # {
  #   "population_male": 392,
  #   "population": 767,
  #   "population_female": 375,
  #   "label": "L'Abergement-Clémenciat (commune non irisée)",
  #   "census": 2016,
  #   "iris": "010010000",
  #   "city": "L'Abergement-Clémenciat",
  #   "citycode": "01001"
  # }

  body <- content(donnees_sex, as="parsed")

  NombreHommes <- body$population_male
  NombreFemmes <- body$population_female
  Pop <- body$population
  Annees <- body$census

  adresses[i,"Hommes"] <- NombreHommes
  adresses[i,"Femmes"] <- NombreFemmes
  adresses[i, "population"] <- Pop
  adresses[i,"annee_recensement"] <- Annees
}
adresses

Nous avons créee 4 nouvelles colonnes à la table adresses qui sont : le nombre d’hommes, de femmes, la population totale de l’IRIS et l’année de recensement de ces informations.

3.2 Coordonnées X/Y :

By default, st_join() performs a left join, meaning that the result is an object containing all rows from x including rows with no match in y (see Section 3.2.4), but it can also do inner joins by setting the argument left = FALSE. Like spatial subsetting, the default topological operator used by st_join() is st_intersects(), which can be changed by setting the join argument (see ?st_join for details). https://geocompr.robinlovelace.net/spatial-operations.html

names(adresses)
##  [1] "VOIE"              "CPOST_TUMEUR"      "CINSEE_TUMEUR"    
##  [4] "latitude"          "longitude"         "CODE_IRIS"        
##  [7] "Hommes"            "Femmes"            "population"       
## [10] "annee_recensement"
adressesXY <- as.data.frame(adresses)
adressesXY <- adressesXY[,-(4:10)]

head(adressesXY)
################## Prendre les coordonnées X/Y : 
Sys.setenv(http_proxy = "https://cache.univ-poitiers.fr:3128", https_proxy="http://cache.univ-poitiers.fr:3128")
library(httr)

callAPI <- function (voie, Cpost, CInsee){
  voie_sansEspace<- gsub (" ", "+", voie)
  MyURL <- paste ("https://api-adresse.data.gouv.fr/search/?q", voie_sansEspace, sep="=")
  #On a bien des adresses sans espace qui sont ratachées à l'URl
  #qu'il nous faut mais on se retrouve avec le problème des lignes qui n'ont pas d'adresses. 
  
  #Objectif numero 2 : https://api-adresse.data.gouv.fr/search/?q=8+bd+du+port&postcode=44380
  postcode <- paste ("postcode", Cpost, sep = "=")
  URL11 <- paste(MyURL,postcode, sep = "&")
  
  #objectif num�ro 3 : https://api-adresse.data.gouv.fr/search/?q=paris&citycode=75056
  citycode <- paste("citycode", CInsee, sep = "=")
  URL12 <- paste(URL11, citycode, sep = "&")
  
  #objectif num�ro 4 : https://api-adresse.data.gouv.fr/search/?q=8+bd+du+port&limit=15
  #avec une limite de 1 pour avoir le r�sultat le plus pertinent. 
  URLfinale <- paste(URL12, "limit=1", sep = "&")
  
  Coordonnees <- GET(URLfinale)
  body <- content(Coordonnees, as="parsed")
  
  X <- body$features[[1]]$properties$x
  Y <- body$features[[1]]$properties$y
  
  
  return(c(X,Y))
  
}


### D�but de lecture du code

for(row in 1:nrow(adressesXY)) {
  voie <- gsub("[[:punct:]]", "", adressesXY[row, "VOIE"])
  Cpost <- gsub("[[:punct:]]", "", adressesXY [row, "CPOST_TUMEUR"])
  CInsee <- gsub("[[:punct:]]", "", adressesXY [row, "CINSEE_TUMEUR"])
  
  Adresse_totale <- callAPI (voie,Cpost, CInsee)
  print(Adresse_totale)
  adressesXY[row, "X"] <- Adresse_totale[1]
  adressesXY[row, "Y"] <- Adresse_totale[2]
  
}
## [1]  500240.9 6609878.8
## [1]  506369.5 6614367.5
## [1]  502734.1 6616683.4
## [1]  502577.2 6610242.2
## [1]  440999.3 6516472.5
## [1]  497940.8 6612017.2
## [1]  478231.5 6467626.6
## [1]  351951.5 6577463.8
## [1]  452999.8 6536519.4
## [1]  430169.8 6508744.5
## [1]  434172 6524939
## [1]  387700 6507846
## [1]  383011.2 6551165.9
#head(Contours_IRIS)
#Contours_IRIS <- st_set_crs(Contours_IRIS, 2154)

library(sf)
adressesXY <- adressesXY %>%
  st_as_sf(coords = c("X", "Y")) %>%
  st_cast("POINT")

adressesXY <- st_set_crs(adressesXY, 2154)
Essai <- st_join(adressesXY, Contours_IRIS)

4 Regroupement des données :

4.1 Départements :

Nous souhaitons afficher sur notre carte seulement les IRIS correspondants aux départements de notre zone d’étude (Charente (16), Charente-Maritime (17), Deux-Sèvres (79) et Vienne (86)). La table Contours_IRIS ne comporte pas cette donnée mais nous pouvons la retrouver avec un autre fichier donnée par l’INSEE : “Liste des communes” (//www.insee.fr/fr/information/6051727).

Contours_IRIS <- st_read("R://Masters//Stage_G_BARETH//Geocodage//IRIS//IRIS_EDI//CONTOURS-IRIS_2-1__SHP__FRA_2021-01-01//CONTOURS-IRIS//1_DONNEES_LIVRAISON_2021-06-00217//CONTOURS-IRIS_2-1_SHP_LAMB93_FXX-2021")
## Reading layer `CONTOURS-IRIS' from data source 
##   `R:\Masters\Stage_G_BARETH\Geocodage\IRIS\IRIS_EDI\CONTOURS-IRIS_2-1__SHP__FRA_2021-01-01\CONTOURS-IRIS\1_DONNEES_LIVRAISON_2021-06-00217\CONTOURS-IRIS_2-1_SHP_LAMB93_FXX-2021' 
##   using driver `ESRI Shapefile'
## Simple feature collection with 48589 features and 6 fields
## Geometry type: MULTIPOLYGON
## Dimension:     XY
## Bounding box:  xmin: 99040 ymin: 6049662 xmax: 1242445 ymax: 7110479
## Projected CRS: RGF93 / Lambert-93
Departements <-  read.csv("R:\\Masters\\Stage_G_BARETH\\Geocodage\\IRIS\\IRIS_EDI\\commune_2022.csv")
head(Contours_IRIS)
head(Departements)

Il va falloir rassembler les deux tables en une seule afin d’avoir toutes les informations que nous souhaitons et pour se faire utiliser la fonction merge. ATTENTION : Il faut veiller à choisir la bonne colonne commune à nos deux tables afin que notre ordinateur affecte les bonnes informations aux bonnes lignes déjà existantes. Dans notre exemple, la colonne COM dans Departements et la colonne INSEE_COM dans Contours_IRIS comporte les mêmes données mais non pas le même nom. Il va falloir changer ce point et merger les deux tables ensemble pour en créer une nouvelle IRIS_avec_Departement.

names(Departements) <- c( "TYPECOM","INSEE_COM","REG","DEP","CTCD","ARR","TNCC","NCC","NCCENR","LIBELLE","CAN","COMPARENT")
IRIS_avec_Departement <- merge(Contours_IRIS,Departements,by="INSEE_COM")
head(IRIS_avec_Departement)

Maintenant que nous avons nos nouvelles colonnes, nous pouvons découper notre tableau pour en créer de nouveaux, centrés sur les départements que nous souhaitons.

Charentes <-  subset(IRIS_avec_Departement, IRIS_avec_Departement$DEP=="16")
Charentes_maritime <-  subset(IRIS_avec_Departement, IRIS_avec_Departement$DEP=="17")
Deux_sevres <- subset(IRIS_avec_Departement, IRIS_avec_Departement$DEP=="79")
Vienne <- subset(IRIS_avec_Departement, IRIS_avec_Departement$DEP=="86")
head(Vienne)

4.2 Adresses :

Notre tableau de données adresses contient désormais une nouvelle colonne : CODE_IRIS. Mais nous n’avons toujours pas les coordonnées géographiques du polygonne correspondant à cet IRIS, cependant nous savons que cela est contenu dans le tableau de données IRIS_avec_Departement. Il faut à leurs tours les merger cette fois sur la colonne CODE_IRIS qu’elles ont en commun.

IRIS_avec_Departement_NosAdresses <- merge(IRIS_avec_Departement, adresses, all.x = TRUE,  by = "CODE_IRIS")
head(IRIS_avec_Departement_NosAdresses)

5 Carte :

5.1 tmap :

tmap est un package dédié à la réalisation de cartes sous R qui nécessite la librairie tmap pour fonctionner.
Pour charger une donnée géométrique, il faut utiliser la fonction tm_shape() avec l’opérateur + pour enchainer les options.
tm_polygons() permet d’afficher les polygones.
tmap_mode("view") permet simplement de convertir une carte image en carte interactive.

5.1.1 Découpage en IRIS :

library(tmap)
tm_shape(Vienne) +  tm_polygons()

library(tmap)
tm_shape(Vienne) +  tm_polygons() + tmap_mode("view")
## tmap mode set to interactive viewing

5.1.2 Villes et mes IRIS :

Pour savoir quelles les villes qui contiennent les IRIS de mes adresses de départ, et afficher spécifiquement ces IRIS, nous créons deux nouvelles variables cities et irisDeMesAdresses.
cities est un sous ensemble de IRIS_avec_Departement_NosAdresses qui ne contient que les lignes dont la colonne NOM_COM équivaut à l’un des noms de villes que nous sommes allés chercher avec la seconde API.
Même chose pour irisDeMesAdresses.
In sf::st_is_longlat(shp2)

cities <-  subset(IRIS_avec_Departement_NosAdresses, IRIS_avec_Departement_NosAdresses$NOM_COM %in% villes)
irisDeMesAdresses <-  subset(IRIS_avec_Departement_NosAdresses, IRIS_avec_Departement_NosAdresses$CODE_IRIS %in% codeIris)
library(tmap)
tm_shape(Vienne) +  tm_polygons() +
tm_shape(cities) + tm_polygons() +
tm_shape(irisDeMesAdresses) + tm_polygons()+
tmap_mode("view")
## tmap mode set to interactive viewing

5.1.3 Carte choroplèthe :

“Une carte choroplèthe (du grec χῶρος : « zone/région » et πλῆθος : « grand nombre, multitude ») est une carte thématique où les régions sont colorées ou remplies d’un motif qui montre une mesure statistique, tels la densité de population ou le revenu par habitant. Ce type de carte facilite la comparaison d’une mesure statistique d’une région à l’autre ou montre la variabilité de celle-ci pour une région donnée” (https://fr.wikipedia.org/wiki/Carte_choropl%C3%A8the)

library(tmap)

tm_shape(Charentes) +  tm_polygons() +
  tm_shape(cities) + tm_polygons() +
  tm_shape(irisDeMesAdresses) + tm_polygons("population", palette = "RdYlBu") +
  tmap_mode("view")
## tmap mode set to interactive viewing

5.1.4 Points exactes :

Il est également possible de représenter sur la carte l’endroit exacte d’habitation de nos patients (ici factices). Pour ce faire, il faut préciser à R que les coordonnées longitutes et latitudes qu’il est en train de lire doivent être représentées en points selon une représentation géographique précise : Coordinates Reference System (CRS).
EPSG:4326 Geodetic coordinate system for World. Horizontal component of 3D system. Used by the GPS satellite navigation system and for NATO military

adresse_precises <- as.data.frame(irisDeMesAdresses)
adresse_precises[,"geometry"] <- paste(adresse_precises[,"latitude"], adresse_precises[,"longitude"], sep = "," )
adresse_precises <- adresse_precises %>%
  st_as_sf(coords = c("longitude", "latitude"), crs = 4326) %>%
  st_cast("POINT")
library(tmap)

tm_shape(Charentes) +  tm_polygons() +
  tm_shape(cities) + tm_polygons() +
  tm_shape(irisDeMesAdresses) + tm_polygons("population", palette = "RdYlBu") +
  tm_shape(adresse_precises) + tm_dots(size = 0.05) +
  tmap_mode("view")
## tmap mode set to interactive viewing

5.2 Plot :

5.2.1 Départements :

library(sf)
plot(st_geometry(Vienne))

library(sf)
plot(st_geometry(Vienne))

plot(st_geometry(Charentes, add = TRUE ))

#plot(st_geometry(Charentes_maritime), add = TRUE)
#plot(st_geometry(Deux_sevres), add = TRUE)

5.2.2 villes et mes IRIS :

library(sf)
plot(st_geometry(Vienne))

plot(st_geometry(Charentes, add = TRUE ))
plot(st_geometry(Charentes_maritime), add = TRUE)
plot(st_geometry(Deux_sevres), add = TRUE)

plot(st_geometry(cities), col = "green", add = TRUE)
plot(st_geometry(irisDeMesAdresses), pch = 3, col = 'blue', add = TRUE)